/*
 * 
 * ....................................................................
 * ...######..#####.....##....####..#####..####..#####..######....##...
 * .....##....##..#....###...##.....##.....##....##..#....##.....###...
 * .....##....####....#.##....##....####...####..####.....##....#.##...
 * .....##....##.#...#####.....##...##.....##....##.#.....##...#####...
 * .....##....##..#.#...##..####....##.....####..##..#....##..#...##...
 * ....................................................................
 */

package ua.trasferta.common.pattern;

import ua.trasferta.common.annotations.createBy;
import static ua.trasferta.common.team.TeamMember.*;

/**
 * <p>
 * TODO: Document me <br>
 * </p>
 * 
 * @author Anton Podviaznikov
 */
@createBy(authors = ANTON_PODVIAZNIKOV)
public enum Pattern
{
	/**
	 * Provide an interface for creating families of related or dependent
	 * objects without specifying their concrete classes.
	 */
	FACTORY,
	/**
	 * Ensure a class has only one instance, and provide a global point of
	 * access to it.
	 */
	SINGLETON,
	/**
	 * Separate the construction of a complex object from its representation so
	 * that the same construction process can create different representations.
	 */
	BUILDER,
	/**
	 * Specify the kinds of objects to create using a prototypical instance, and
	 * create new objects by copying this prototype.
	 */
	PROTOTYPE,
	/**
	 * Define the skeleton of an algorithm in an operation, deferring some steps
	 * to subclasses. Template Method lets subclasses redefine certain steps of
	 * an algorithm without changing the algorithm's structure.
	 */
	TEMPLATE,
	/**
	 * Convert the interface of a class into another interface clients expect.
	 * Adapter lets classes work together that couldn't otherwise because of
	 * incompatible interfaces.
	 */
	ADAPTER,
	/**
	 * Compose objects into tree structures to represent part-whole hierarchies.
	 * Composite lets clients treat individual objects and compositions of
	 * objects uniformly.
	 */
	COMPOSITE,
	/**
	 * Attach additional responsibilities to an object dynamically keeping the
	 * same interface. Decorators provide a flexible alternative to subclassing
	 * for extending functionality.
	 */
	DECORATOR,
	/**
	 * Provide a unified interface to a set of interfaces in a subsystem. Facade
	 * defines a higher-level interface that makes the subsystem easier to use.
	 */
	FACADE,
	/**
	 * Decouple an abstraction from its implementation so that the two can vary
	 * independently.
	 */
	BRIDGE,
	/**
	 * Use sharing to support large numbers of fine-grained objects efficiently.
	 */
	FLYWEIGHT,
	/**
	 * Define a one-to-many dependency between objects so that when one object
	 * changes state, all its dependents are notified and updated automatically.
	 */
	OBSERVER,
	/**
	 * Define an object that encapsulates how a set of objects interact.
	 * Mediator promotes loose coupling by keeping objects from referring to
	 * each other explicitly, and it lets you vary their interaction
	 * independently.
	 */
	MEDIATOR,
	/**
	 * epresent an operation to be performed on the elements of an object
	 * structure. Visitor lets you define a new operation without changing the
	 * classes of the elements on which it operates.
	 */
	VISITOR,
	/**
	 * Allow an object to alter its behavior when its internal state changes.
	 * The object will appear to change its class.
	 */
	STATE,
	/**
	 * Encapsulate a request as an object, thereby letting you parameterize
	 * clients with different requests, queue or log requests, and support
	 * undoable operations.
	 */
	COMMAND,
	/**
	 * Provide a way to access the elements of an aggregate object sequentially
	 * without exposing its underlying representation.
	 */
	ITERATOR,
	/**
	 * Define a family of algorithms, encapsulate each one, and make them
	 * interchangeable. Strategy lets the algorithm vary independently from
	 * clients that use it.
	 */
	STRATEGY;
}
